// 遗物类
class Relic {
    constructor(name, description, effect, rarity = 'common') {
        this.name = name;
        this.description = description;
        this.effect = effect;
        this.rarity = rarity; // common, uncommon, rare, legendary
        this.used = false;
    }

    // 激活遗物效果
    activate(player) {
        if (this.used) return false;
        
        switch (this.effect.type) {
            case 'passive':
                this.applyPassiveEffect(player);
                break;
            case 'active':
                this.applyActiveEffect(player);
                break;
            case 'trigger':
                this.setupTrigger(player);
                break;
        }
        
        return true;
    }

    // 应用被动效果
    applyPassiveEffect(player) {
        switch (this.name) {
            case '滑板车':
                player.maxEnergy += 1;
                player.energy += 1;
                break;
            case '汽车':
                player.maxHealth += 20;
                player.health += 20;
                break;
            case 'T恤':
                player.addStrength(1, 'permanent');
                break;
            case '手机':
                player.maxHandSize += 1;
                break;
            case '眼镜':
                player.addIntelligence(1, 'permanent');
                break;
            case '运动鞋':
                player.addDexterity(1, 'permanent');
                break;
            case '手表':
                // 每回合开始时抽1张牌
                break;
            case '耳机':
                // 免疫第一次伤害
                break;
            case '书包':
                // 每场战斗开始时获得1张随机卡牌
                break;
            case '计算器':
                // 数学类卡牌伤害+2
                break;
            case '字典':
                // 语文类卡牌效果+1
                break;
            case '单词本':
                // 英语类卡牌消耗-1
                break;
            case '实验器材':
                // 科学类卡牌效果翻倍
                break;
            case '历史书':
                // 历史类卡牌获得额外效果
                break;
        }
    }

    // 应用主动效果
    applyActiveEffect(player) {
        switch (this.name) {
            case '能量饮料':
                player.energy += 2;
                break;
            case '急救包':
                player.heal(30);
                break;
        }
    }

    // 设置触发效果
    setupTrigger(player) {
        // 实现触发效果
    }
}

// 遗物数据库
class RelicDatabase {
    constructor() {
        this.relics = this.initializeRelics();
    }

    // 初始化所有遗物
    initializeRelics() {
        return [
            // 普通遗物
            new Relic('滑板车', '增加1点最大能量', { type: 'passive' }, 'common'),
            new Relic('T恤', '增加1点力量', { type: 'passive' }, 'common'),
            new Relic('眼镜', '增加1点智力', { type: 'passive' }, 'common'),
            new Relic('运动鞋', '增加1点敏捷', { type: 'passive' }, 'common'),
            new Relic('入学礼包', '前4层：每场战斗开始获得1点力量与1点敏捷', { type: 'trigger' }, 'common'),
            new Relic('计算器', '数学类卡牌伤害+2', { type: 'passive' }, 'common'),
            new Relic('字典', '语文类卡牌效果+1', { type: 'passive' }, 'common'),
            new Relic('单词本', '英语类卡牌消耗-1', { type: 'passive' }, 'common'),
            new Relic('历史书', '历史类卡牌获得额外效果', { type: 'passive' }, 'common'),
            new Relic('地图', '地理类卡牌获得额外效果', { type: 'passive' }, 'common'),
            
            // 罕见遗物
            new Relic('汽车', '增加20点最大生命值', { type: 'passive' }, 'uncommon'),
            new Relic('手机', '增加1张手牌上限', { type: 'passive' }, 'uncommon'),
            new Relic('手表', '每回合开始时抽1张牌', { type: 'trigger' }, 'uncommon'),
            new Relic('耳机', '免疫第一次伤害', { type: 'trigger' }, 'uncommon'),
            new Relic('书包', '每场战斗开始时获得1张随机卡牌', { type: 'trigger' }, 'uncommon'),
            new Relic('实验器材', '科学类卡牌效果翻倍', { type: 'passive' }, 'uncommon'),
            new Relic('智慧之书', '每使用3张技能卡，抽1张牌', { type: 'trigger' }, 'uncommon'),
            new Relic('能量核心', '每回合开始时获得1点额外能量', { type: 'trigger' }, 'uncommon'),
            new Relic('生命之泉', '每回合结束时恢复5点生命值', { type: 'trigger' }, 'uncommon'),
            new Relic('学霸笔记', '每回合开始时获得1张随机技能卡', { type: 'trigger' }, 'uncommon'),
            
            // 稀有遗物
            new Relic('能量饮料', '主动使用：获得2点能量', { type: 'active' }, 'rare'),
            new Relic('急救包', '主动使用：恢复30点生命值', { type: 'active' }, 'rare'),
            new Relic('力量之环', '每造成10点伤害，获得1点力量', { type: 'trigger' }, 'rare'),
            new Relic('敏捷之靴', '每获得5点护甲，获得1点敏捷', { type: 'trigger' }, 'rare'),
            new Relic('智力之冠', '每使用5张技能卡，获得1点智力', { type: 'trigger' }, 'rare'),
            new Relic('幸运符', '每场战斗开始时获得1个随机遗物效果', { type: 'trigger' }, 'rare'),
            new Relic('考试宝典', '所有卡牌消耗-1（最少为0）', { type: 'passive' }, 'rare'),
            new Relic('时间管理', '每回合可以额外行动1次', { type: 'passive' }, 'rare'),
            new Relic('专注力', '免疫所有负面状态', { type: 'passive' }, 'rare'),
            new Relic('记忆力', '每场战斗开始时，手牌中所有卡牌消耗-1', { type: 'trigger' }, 'rare'),
            new Relic('创造力', '每使用1张技能卡，获得1点随机属性', { type: 'trigger' }, 'rare'),
            new Relic('拾金不昧奖章', '战斗开始时获得3点临时力量与敏捷（持续1回合）', { type: 'trigger' }, 'rare'),
            // 带负面效果的强力遗物（稀有）
            new Relic('诅咒之书', '所有卡牌伤害+50%，但每回合开始时失去1点最大生命值', { type: 'passive', negative: true }, 'rare'),
            new Relic('狂战士之怒', '每回合开始时获得3点力量，但每回合结束时失去2点生命值', { type: 'trigger', negative: true }, 'rare'),
            new Relic('透支生命', '每场战斗开始时获得2点能量，但战斗结束后失去5点最大生命值', { type: 'trigger', negative: true }, 'rare'),
            new Relic('恶魔契约', '所有卡牌消耗-2（最少为0），但每使用1张卡牌失去1点生命值', { type: 'passive', negative: true }, 'rare'),
            // VIP卡遗物（商店折扣）
            new Relic('超级VIP卡', '商店购买所有商品享受5折优惠', { type: 'passive' }, 'rare'),
            new Relic('普通VIP卡', '商店购买所有商品享受7折优惠', { type: 'passive' }, 'uncommon')
        ];
    }

    // 获取随机遗物
    getRandomRelic(rarity = 'common') {
        const filteredRelics = this.relics.filter(relic => relic.rarity === rarity);
        if (filteredRelics.length === 0) return null;
        return filteredRelics[Math.floor(Math.random() * filteredRelics.length)];
    }

    // 获取随机遗物池
    getRandomRelicPool(count = 3, rarity = 'common') {
        const filteredRelics = this.relics.filter(relic => relic.rarity === rarity);
        const shuffled = [...filteredRelics].sort(() => 0.5 - Math.random());
        return shuffled.slice(0, count);
    }

    // 根据稀有度获取遗物
    getRelicsByRarity(rarity) {
        return this.relics.filter(relic => relic.rarity === rarity);
    }

    // 获取所有遗物
    getAllRelics() {
        return this.relics;
    }

    // 根据名称获取遗物
    getRelicByName(name) {
        return this.relics.find(relic => relic.name === name);
    }
}

// 遗物效果处理器
class RelicEffectProcessor {
    static processRelic(relic, player, context = {}) {
        switch (relic.name) {
            case '滑板车':
                player.maxEnergy += 1;
                player.energy += 1;
                break;
                
            case '汽车':
                player.maxHealth += 20;
                player.health += 20;
                break;
                
            case 'T恤':
                player.addStrength(1, 'permanent');
                break;
                
            case '手机':
                player.maxHandSize += 1;
                break;
                
            case '眼镜':
                player.addIntelligence(1, 'permanent');
                break;
                
            case '运动鞋':
                player.addDexterity(1, 'permanent');
                break;
                
            case '手表':
                if (context.phase === 'turnStart') {
                    // 抽1张牌（通过game实例的方法，确保遵守手牌上限）
                    if (context.game && context.game.playerDeck && context.game.playerDeck.length > 0) {
                        const card = context.game.playerDeck.pop();
                        context.game.addCardToHand(card);
                    }
                }
                break;
                
            case '耳机':
                if (context.phase === 'damage') {
                    // 免疫第一次伤害
                    if (!player.hasUsedHeadphones) {
                        player.hasUsedHeadphones = true;
                        return { immune: true };
                    }
                }
                break;
                
            case '书包':
                if (context.phase === 'battleStart') {
                    // 获得1张随机卡牌（通过game实例的方法，确保遵守手牌上限）
                    const randomCard = cardDatabase.getRandomCard();
                    if (context.game && randomCard) {
                        const addedToHand = context.game.addCardToHand(randomCard);
                        if (!addedToHand) {
                            // 如果放入弃牌堆，记录日志
                            context.game.addBattleLog('书包：手牌已满，随机卡牌放入弃牌堆');
                        }
                    }
                }
                break;
                
            case '计算器':
                if (context.cardType === 'math') {
                    context.damage += 2;
                }
                break;
                
            case '字典':
                if (context.cardType === 'chinese') {
                    context.effect += 1;
                }
                break;
                
            case '单词本':
                if (context.cardType === 'english') {
                    context.cost = Math.max(0, context.cost - 1);
                }
                break;
                
            case '实验器材':
                if (context.cardType === 'science') {
                    context.effect *= 2;
                }
                break;
                
            case '历史书':
                if (context.cardType === 'history') {
                    context.effect += 1;
                }
                break;
                
            case '地图':
                if (context.cardType === 'geography') {
                    context.effect += 1;
                }
                break;
                
            case '能量饮料':
                if (context.phase === 'active') {
                    player.energy += 2;
                }
                break;
                
            case '急救包':
                if (context.phase === 'active') {
                    player.heal(30);
                }
                break;
                
            case '智慧之书':
                if (context.phase === 'skillUsed') {
                    player.skillCardCount = (player.skillCardCount || 0) + 1;
                    if (player.skillCardCount >= 3) {
                        player.skillCardCount = 0;
                        // 通过game实例的方法，确保遵守手牌上限
                        if (context.game && context.game.playerDeck && context.game.playerDeck.length > 0) {
                            const card = context.game.playerDeck.pop();
                            context.game.addCardToHand(card);
                        }
                    }
                }
                break;
                
            case '力量之环':
                if (context.phase === 'damageDealt') {
                    player.damageDealt = (player.damageDealt || 0) + context.damage;
                    if (player.damageDealt >= 10) {
                        player.damageDealt = 0;
                        player.addStrength(1, 'permanent');
                    }
                }
                break;
                
            case '敏捷之靴':
                if (context.phase === 'blockGained') {
                    player.blockGained = (player.blockGained || 0) + context.block;
                    if (player.blockGained >= 5) {
                        player.blockGained = 0;
                        player.addDexterity(1, 'permanent');
                    }
                }
                break;
                
            case '智力之冠':
                if (context.phase === 'skillUsed') {
                    player.skillCardCount = (player.skillCardCount || 0) + 1;
                    if (player.skillCardCount >= 5) {
                        player.skillCardCount = 0;
                        player.addIntelligence(1, 'permanent');
                    }
                }
                break;
                
            case '生命之泉':
                if (context.phase === 'turnEnd') {
                    player.heal(5);
                }
                break;
                
            case '能量核心':
                if (context.phase === 'turnStart') {
                    player.energy += 1;
                }
                break;
                
            case '幸运符':
                if (context.phase === 'battleStart') {
                    // 获得1个随机遗物效果
                    const randomRelic = relicDatabase.getRandomRelic();
                    RelicEffectProcessor.processRelic(randomRelic, player, context);
                }
                break;
                
            case '考试宝典':
                // 所有卡牌消耗-1（最少为0）
                if (context.phase === 'cardCost') {
                    context.cost = Math.max(0, context.cost - 1);
                }
                break;
                
            case '学霸笔记':
                if (context.phase === 'turnStart') {
                    // 获得1张随机技能卡（通过game实例的方法，确保遵守手牌上限）
                    const skillCards = cardDatabase.cards.common_cards.filter(card => card.type === 'skill');
                    if (skillCards.length > 0 && context.game) {
                        const randomSkillCard = skillCards[Math.floor(Math.random() * skillCards.length)];
                        const addedToHand = context.game.addCardToHand(randomSkillCard);
                        if (!addedToHand) {
                            // 如果放入弃牌堆，记录日志
                            context.game.addBattleLog('学霸笔记：手牌已满，技能卡放入弃牌堆');
                        }
                    }
                }
                break;
                
            case '时间管理':
                // 每回合可以额外行动1次
                if (context.phase === 'turnStart') {
                    player.extraActions = (player.extraActions || 0) + 1;
                }
                break;
                
            case '专注力':
                // 免疫所有负面状态
                if (context.phase === 'negativeEffect') {
                    return { immune: true };
                }
                break;
                
            case '记忆力':
                if (context.phase === 'battleStart') {
                    // 手牌中所有卡牌消耗-1（通过game实例访问手牌）
                    if (context.game && context.game.playerHand) {
                        context.game.playerHand.forEach(card => {
                            card.cost = Math.max(0, card.cost - 1);
                        });
                    }
                }
                break;
                
            case '创造力':
                if (context.phase === 'skillUsed') {
                    // 获得1点随机属性
                    const attributes = ['strength', 'dexterity', 'intelligence'];
                    const randomAttr = attributes[Math.floor(Math.random() * attributes.length)];
                    if (randomAttr === 'strength') {
                        player.addStrength(1, 'permanent');
                    } else if (randomAttr === 'dexterity') {
                        player.addDexterity(1, 'permanent');
                    } else {
                        player.addIntelligence(1, 'permanent');
                    }
                }
                break;

            case '拾金不昧奖章':
                if (context.phase === 'battleStart') {
                    if (player.statusManager) {
                        player.statusManager.addStatus(new Status('力量', 1, 3, '奖章加持'));
                        player.statusManager.addStatus(new Status('敏捷', 1, 3, '奖章加持'));
                    }
                }
                break;

            case '入学礼包':
                if (context.phase === 'battleStart') {
                    const floor = context.floor || 1;
                    if (floor <= 4 && player.statusManager) {
                        player.statusManager.addStatus(new Status('力量', 1, 1, '入学礼包'));
                        player.statusManager.addStatus(new Status('敏捷', 1, 1, '入学礼包'));
                    }
                }
                break;

            // 带负面效果的强力遗物
            case '诅咒之书':
                // 被动：所有卡牌伤害+50%（在dealDamage中处理）
                // 负面：每回合开始时失去1点最大生命值
                if (context.phase === 'turnStart') {
                    player.maxHealth = Math.max(1, player.maxHealth - 1);
                    player.health = Math.min(player.health, player.maxHealth);
                }
                break;

            case '狂战士之怒':
                // 正面：每回合开始时获得3点力量
                // 负面：每回合结束时失去2点生命值
                if (context.phase === 'turnStart') {
                    player.addStrength(3, 'turn');
                } else if (context.phase === 'turnEnd') {
                    player.takeDamage(2);
                }
                break;

            case '透支生命':
                // 正面：每场战斗开始时获得2点能量
                // 负面：战斗结束后失去5点最大生命值
                if (context.phase === 'battleStart') {
                    player.energy += 2;
                    // 不增加最大能量，只是临时能量
                } else if (context.phase === 'battleEnd') {
                    player.maxHealth = Math.max(1, player.maxHealth - 5);
                    player.health = Math.min(player.health, player.maxHealth);
                }
                break;

            case '恶魔契约':
                // 被动：所有卡牌消耗-2（在useCard中处理）
                // 负面：每使用1张卡牌失去1点生命值（在useCard中处理）
                // 这里只处理被动效果，负面效果在game.js中处理
                break;
        }
    }
}

// 全局遗物数据库实例
const relicDatabase = new RelicDatabase();
